<template>
  <a-card :bordered="false">
  </a-card>
</template>

<script>

  import '@/assets/less/TableExpand.less'
  import { mixinDevice } from '@/utils/mixin'
  import { JeecgListMixin } from '@/mixins/JeecgListMixin'
  import Vue from 'vue'
  import { getAction } from '@api/manage'
  import { deepClone } from '@/utils/util'

  export default {
    name: 'getRowToColumns',
    mixins:[JeecgListMixin, mixinDevice],
    components: {
    },
    props:{
      url:{
        type: String,
        default: ''
      },
      params: Object,
      gudingColumns: Array,
      dongtaiColumns: Array

    },
    data () {
      return {
        //表头
        columns:[],
        //列设置
        settingColumns:[],
        defColumns: [],
        dictOptions:{},
        superFieldList:[],
      }
    },
    created() {

    },
    computed: {
      importExcelUrl: function(){
        return `${window._CONFIG['domianURL']}/${this.url.importExcelUrl}`;
      },
    },
    methods: {
      //动态列 script 1 ////////////////////////////////////////////////////////////////////////////////////////
      // 列设置更改事件
      onColSettingsChange (checkedValues) {
        var key = this.$route.name+":colsettings";
        Vue.ls.set(key, checkedValues, 7 * 24 * 60 * 60 * 1000)
        this.settingColumns = checkedValues;
        const cols = this.defColumns.filter(item => {
          if(item.key =='rowIndex'|| item.dataIndex=='action'){
            return true
          }
          if (this.settingColumns.includes(item.dataIndex)) {
            return true
          }
          return false
        })
        this.columns =  cols;
      },


      initColumns(){
        //权限过滤（列权限控制时打开，修改第二个参数为授权码前缀）
        //this.defColumns = colAuthFilter(this.defColumns,'testdemo:');
        this.settingColumns = [];

        var key = this.$route.name+":colsettings";
        let colSettings= Vue.ls.get(key);
        if(colSettings==null||colSettings==undefined){
          let allSettingColumns = [];
          this.defColumns.forEach(function (item,i,array ) {
            allSettingColumns.push(item.dataIndex);
          })
          this.settingColumns = allSettingColumns;
          this.columns = this.defColumns;
        }else{
          this.settingColumns = colSettings;
          const cols = this.defColumns.filter(item => {
            if(item.key =='rowIndex'|| item.dataIndex=='action'){
              return true;
            }
            if (colSettings.includes(item.dataIndex)) {
              return true;
            }
            return false;
          })
          this.columns =  cols;
        }
      },
      loadDataTrRow2ColInitColumns(testdata){
        this.defColumns = []; //置空设置，防止重复设置
        this.columns = []; //置空设置，防止重复设置
        if(testdata == undefined || testdata == null ){
          
          getAction(this.url,this.params).then((res) => {
            if (res.success){
              testdata = res.result.records;
              // this.loadDataTrRow2ColUtil3(testdata);
              this.loadDataTrRow2ColInitColumns(testdata);
            }
          });
        }
        //第一次遍历，制做 表头
        var th = [];
        // th = this.gudingColumns; //表头 [{}] //浅拷贝
        //th = util.deepCopy(this.gudingColumns); //表头 [{}] //深拷贝
        // th = JSON.parse(JSON.stringify(this.gudingColumns)) //表头 [{}] //深拷贝1:该方法不能解决属性为函数，undefined，循环引用的的情况
        // th = cloneObject(this.gudingColumns) //深拷贝1

        // Object.assign([],th,this.gudingColumns) //表头 [{}] //深拷贝2:Object.assign 方法只会拷贝源对象自身的并且可枚举的属性到目标对象，继承属性和不可枚举属性是不能拷贝的。
        //针对深拷贝，需要使用其他办法，因为 Object.assign()拷贝的是属性值。假如源对象的属性值是一个对象的引用，那么它也只指向那个引用。
        //目前IE浏览器不兼容Object.assign()
        th = deepClone(this.gudingColumns);//表头 [{}] //深拷贝3:自定义递归函数解决深拷贝问题

        var thKeyCol = {}; //动态关键列,需重新定义，动态获取


        //筛选科目分项
        var thKey = {}
        for (var i = 0; i < testdata.length; i++) {
          var d = testdata[i];
          var dontaicolName = this.dongtaiColumns[0].dataIndex;
          var dontaicolId = this.dongtaiColumns[0].dataIndexId;
          if(  d[dontaicolName] != undefined && d[dontaicolName] != null && d[dontaicolName] != 'null' && d[dontaicolName] != '' ){
            // thKey[d[dontaicolName] ] =1 ;
            thKey[d[dontaicolName] ] = d[dontaicolId];  //动态列

            // thKey[eval("d."+dontaicolId)] =2;
          }
          else if(d[dontaicolName] == null || d[dontaicolName] != 'null' || d[dontaicolName] != ''){
            thKey[this.dongtaiColumns[0].nulldatacolname ] = this.dongtaiColumns[0].nulldatacolname;  //动态列

          }
          else{
            thKey['-1'] = '-1';
          }

          // if(  d[dontaicolId] != undefined && d[dontaicolId] != null && d[dontaicolId] != 'null' && d[dontaicolId] != '' ){
          //   thKey[d[dontaicolId] ] = 2;  //动态列
          // }

        }

        //把科目加到th里面 ，动态增长列
        // for (var key in Object.keys(thKey))
        for (var key in thKey){
          var colobj = { title: key, align:"center",dataIndex:thKey[key]};
          th.push(colobj) ;
          thKeyCol[key] = key;
        }
        // this.tableHeader = th;
        //重新定义列，增加动态列
        // if (this.defColumns == undefined || this.defColumns == null || this.defColumns.length ==0 ){
        //   this.defColumns = th;
        //   // this.initColumns();
        // }
        // if (this.columns == undefined || this.columns == null || this.columns.length ==0){
        //   this.columns = th;
        // }
        this.defColumns = th;
        this.columns = th;
        this.initColumns();
      },
      loadDataTrRow2ColInitDatas(testdata){
        //第二次遍历，制做tr的行
        var tr = []; //数据 [{}]

        for (var i = 0; i < testdata.length; i++) {
          var d = testdata[i];
          var rowdata = {};
          for(var j=0;j< this.gudingColumns.length;j++){
            rowdata[this.gudingColumns[j].dataIndex] = d[this.gudingColumns[j].dataIndex]; //用对应列的数据赋值给固定列
          }


          //判断对象是否存在，存在则忽略，不存在则插入
          if ( tr.length == 0 ){
            tr.push(rowdata)
          }
          else{
            var insertflag = true;
            for(var k in tr ){
              var eqflag = true;
              for(var rd in rowdata ){
                if(rowdata[rd] !== tr[k][rd]){
                  eqflag = false;
                  continue;
                }
              }
              //判断是否相等
              // if (Object.is(rowdata,tr[k])){
              // if ( this.compare(rowdata,tr[k]) ){
              if ( eqflag ){
                insertflag = false;
              }
              else{
                continue;
              }
            }
            //应当插入则插入：即不存在则插入
            if(insertflag){
              tr.push(rowdata)
            }
          }

        }
        //第三次遍历，添加科目的成绩:动态插入数据列
        for (var i = 0; i < testdata.length; i++) {
          var d = testdata[i];
          //查找应该是tr的第几条数据
          var trindex = -1;
          for(var ti=0;ti<tr.length;ti++){
            var tr_rowdata = tr[ti];//取出1条数据
            var equalflag = true;
            for(var j = 0; j < this.gudingColumns.length ; j++ ){
              if (tr_rowdata[this.gudingColumns[j].dataIndex] != d[this.gudingColumns[j].dataIndex]){ //用对应列的数据赋值给固定列
                equalflag = false;
              }
            }
            //如果相等即找到了,则写入数据,考虑动态列寻找
            if(equalflag ){
              //直接赋值：给对应动态列的值设置为成绩数值（会存在空值串列的情况，需考虑空值设置问题）
              //考虑到数据是通过列名绑定，就不会存在串列问题
              if ( d[this.dongtaiColumns[0].dataIndexId] != undefined && d[this.dongtaiColumns[0].dataIndexId] != null && d[this.dongtaiColumns[0].dataIndexId] != '' ){
                tr_rowdata[d[this.dongtaiColumns[0].dataIndexId]] = d[this.dongtaiColumns[0].valueIndex]+this.dongtaiColumns[0].valueIndexsuffix; //把成绩数据绑定到动态列名上,加后缀单位
              }
              else{
                tr_rowdata[this.dongtaiColumns[0].nulldatacolname] = d[this.dongtaiColumns[0].valueIndex]+this.dongtaiColumns[0].valueIndexsuffix; //把成绩数据绑定到动态列名上,加后缀单位
              }



              //通过循环判断，确定应该给哪个动态列赋值（避免空值串列问题）
              // for (var key in thKeyCol ){
              //   if (d[this.dongtaiColumns[0].dataIndex] == key ) {
              //     tr_rowdata[d[this.dongtaiColumns[0].dataIndexId]] = d[this.dongtaiColumnsValue[0].dataIndex] ;  //动态列的成绩数值
              //   }
              //   else if (tr_rowdata[key] == undefined || tr_rowdata[key] ==null || tr_rowdata[key] == ''){
              //     //补充其他学科为空值
              //     tr_rowdata[key] = null;
              //   }
              //   else if(tr_rowdata[key] != null){
              //     continue;//已经有值了，无需处理
              //   }
              //   else{
              //     //补充其他学科为-1异常情况
              //     tr_rowdata[key] = -1;
              //   }
              // }
            }
            tr[ti] = tr_rowdata; //重新定义一行数据，把动态列数据加入进来
          }

        }

        this.dataSource = tr;  //重新定义数据：用分组动态列进行行列转换后的新数据

      },
      async loadDataTrRow2ColNew(){
        console.log("参数传递值打印： ");
        console.log(this.url);
        console.log(this.dongtaiColumns);
        console.log(this.gudingColumns);
        console.log(this.params);
        //获得测试数据
        // var testdata = this.dataSource ;
        var testdata = [];
        this.defColumns =[];
        this.columns = [];
        this.settingColumns = [];

        
        getAction(this.url,this.params).then((res) => {
          if (res.success){
            testdata = res.result.records;
            // this.loadDataTrRow2ColUtil3(testdata);
            this.loadDataTrRow2ColInitColumns(testdata); //列名已经初始化了，只需初始化1次，不必重复初始化
            this.loadDataTrRow2ColInitDatas(testdata);  //更新数据样式格式
            this.$bus.$emit("projScoreList",{
              defColumns: this.defColumns,
              columns: this.columns,
              settingColumns: this.settingColumns
            })
          }
        });

      },
      //动态列 script 1 ////////////////////////////////////////////////////////////////////////////////////////
    }
  }
</script>
<style scoped>
  @import '~@assets/less/common.less';
</style>